package com.iceframework.core.task.entity;

import java.util.Collection;
import java.util.Comparator;
import java.util.Map;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;

public class ThreadPoolTreeMap<K, V> extends TreeMap<K, V> {

	private static final long serialVersionUID = 1L;

	@Override
	public synchronized int size() {
		return super.size();
	}

	@Override
	public synchronized boolean containsKey(Object key) {
		return super.containsKey(key);
	}

	@Override
	public synchronized boolean containsValue(Object value) {
		return super.containsValue(value);
	}

	@Override
	public synchronized V get(Object key) {
		return super.get(key);
	}

	@Override
	public synchronized Comparator<? super K> comparator() {
		return super.comparator();
	}

	@Override
	public synchronized K firstKey() {
		return super.firstKey();
	}

	@Override
	public synchronized K lastKey() {
		return super.lastKey();
	}

	@Override
	public synchronized void putAll(Map<? extends K, ? extends V> map) {
		super.putAll(map);
	}

	@Override
	public synchronized V put(K key, V value) {
		return super.put(key, value);
	}

	@Override
	public synchronized V remove(Object key) {
		return super.remove(key);
	}

	@Override
	public synchronized void clear() {
		super.clear();
	}

	@Override
	public synchronized Object clone() {
		return super.clone();
	}

	@Override
	public synchronized java.util.Map.Entry<K, V> firstEntry() {
		return super.firstEntry();
	}

	@Override
	public synchronized java.util.Map.Entry<K, V> lastEntry() {
		return super.lastEntry();
	}

	@Override
	public synchronized java.util.Map.Entry<K, V> pollFirstEntry() {

		return super.pollFirstEntry();
	}

	@Override
	public synchronized java.util.Map.Entry<K, V> pollLastEntry() {
		return super.pollLastEntry();
	}

	@Override
	public synchronized java.util.Map.Entry<K, V> lowerEntry(K key) {
		return super.lowerEntry(key);
	}

	@Override
	public synchronized K lowerKey(K key) {
		return super.lowerKey(key);
	}

	@Override
	public synchronized java.util.Map.Entry<K, V> floorEntry(K key) {
		return super.floorEntry(key);
	}

	@Override
	public synchronized K floorKey(K key) {
		return super.floorKey(key);
	}

	@Override
	public synchronized java.util.Map.Entry<K, V> ceilingEntry(K key) {

		return super.ceilingEntry(key);
	}

	@Override
	public synchronized K ceilingKey(K key) {
		return super.ceilingKey(key);
	}

	@Override
	public synchronized java.util.Map.Entry<K, V> higherEntry(K key) {
		return super.higherEntry(key);
	}

	@Override
	public synchronized K higherKey(K key) {
		return super.higherKey(key);
	}

	@Override
	public synchronized Set<K> keySet() {
		return super.keySet();
	}

	@Override
	public synchronized NavigableSet<K> navigableKeySet() {

		return super.navigableKeySet();
	}

	@Override
	public synchronized NavigableSet<K> descendingKeySet() {
		return super.descendingKeySet();
	}

	@Override
	public synchronized Collection<V> values() {
		return super.values();
	}

	@Override
	public synchronized Set<java.util.Map.Entry<K, V>> entrySet() {
		return super.entrySet();
	}

	@Override
	public synchronized NavigableMap<K, V> descendingMap() {
		return super.descendingMap();
	}

	@Override
	public synchronized NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
		return super.subMap(fromKey, fromInclusive, toKey, toInclusive);
	}

	@Override
	public synchronized NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
		return super.headMap(toKey, inclusive);
	}

	@Override
	public synchronized NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
		return super.tailMap(fromKey, inclusive);
	}

	@Override
	public synchronized SortedMap<K, V> subMap(K fromKey, K toKey) {

		return super.subMap(fromKey, toKey);
	}

	@Override
	public synchronized SortedMap<K, V> headMap(K toKey) {
		return super.headMap(toKey);
	}

	@Override
	public synchronized SortedMap<K, V> tailMap(K fromKey) {
		return super.tailMap(fromKey);
	}

	@Override
	public synchronized boolean replace(K key, V oldValue, V newValue) {
		return super.replace(key, oldValue, newValue);
	}

	@Override
	public synchronized V replace(K key, V value) {
		return super.replace(key, value);
	}

	@Override
	public synchronized void forEach(BiConsumer<? super K, ? super V> action) {
		super.forEach(action);
	}

	@Override
	public synchronized void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
		super.replaceAll(function);
	}

}
